"""
定时价格分析任务管理器
"""
import threading
import time
from datetime import datetime
from typing import Optional
from com.db.task_manager import TaskManager
from com.utils.logger import get_logger
from biz.scan_record_price_analyzer import ScanRecordPriceAnalyzer

logger = get_logger("ScheduledPriceAnalyzer")

class ScheduledPriceAnalyzer:
    """定时价格分析器"""
    
    def __init__(self, interval_minutes: int = 20):
        """
        初始化定时分析器
        
        Args:
            interval_minutes: 分析间隔时间（分钟）
        """
        self.interval_minutes = interval_minutes
        self.analyzer = ScanRecordPriceAnalyzer()
        self.task_manager = TaskManager()
        self.running = False
        self.thread: Optional[threading.Thread] = None
        
    def start(self):
        """启动定时分析"""
        if self.running:
            logger.warning("定时分析任务已在运行中")
            return
            
        self.running = True
        self.thread = threading.Thread(target=self._run_analysis_loop, daemon=True)
        self.thread.start()
        logger.info(f"定时分析任务已启动，间隔时间: {self.interval_minutes}分钟")
        
    def stop(self):
        """停止定时分析"""
        if not self.running:
            logger.warning("定时分析任务未在运行")
            return
            
        self.running = False
        if self.thread:
            self.thread.join()
        logger.info("定时分析任务已停止")
        
    def _run_analysis_loop(self):
        """运行分析循环"""
        logger.info("分析循环开始运行")
        logger.info(f"等待 {self.interval_minutes} 分钟后开始第一次分析")
        
        while self.running:
            try:
                # 等待定时时间
                for i in range(self.interval_minutes * 60):
                    if not self.running:
                        logger.info("检测到停止信号，退出分析循环")
                        return
                    time.sleep(1)
                    # 每5分钟记录一次心跳
                    if i % 300 == 0 and i > 0:
                        logger.debug(f"分析器运行中，距离开始分析还有 {self.interval_minutes - (i/60):.1f} 分钟")
                
                # 定时时间到，开始分析
                logger.info("开始新一轮分析")
                self._analyze_all_tasks()
                logger.info(f"分析完成，{self.interval_minutes} 分钟后进行下一轮分析")
                
            except Exception as e:
                logger.error(f"运行分析循环时出错: {str(e)}", exc_info=True)
                # 发生错误时等待1分钟后重试
                time.sleep(60)
        
        logger.info("分析循环已退出")
    
    def _analyze_all_tasks(self):
        """分析所有任务"""
        try:
            # 获取所有活动任务
            tasks = self.task_manager.get_active_tasks()
            if not tasks:
                logger.info("没有活动的任务需要分析")
                return
                
            logger.info(f"开始分析 {len(tasks)} 个任务")
            start_time = datetime.now()
            
            # 每次执行前重新创建 ScanRecordPriceAnalyzer 对象
            # 这样可以确保它会检查最新的账号状态
            self.analyzer = ScanRecordPriceAnalyzer()
            logger.info("已重新创建 ScanRecordPriceAnalyzer 对象")
            
            # 分析每个任务
            for task in tasks:
                try:
                    goods_id = task.get('goods_id')
                    if not goods_id:
                        continue
                        
                    logger.info(f"分析商品 {goods_id}")
                    self.analyzer.analyze_goods(goods_id)
                except Exception as e:
                    logger.error(f"分析商品 {goods_id} 时出错: {str(e)}")
                    continue
            
            end_time = datetime.now()
            duration = (end_time - start_time).total_seconds()
            logger.info(f"完成所有任务分析，耗时: {duration:.2f}秒")
            
        except Exception as e:
            logger.error(f"分析所有任务时出错: {str(e)}")
